package com.yl.system.service.impl;


import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.yl.common.DanmoFontGenerate;
import com.yl.system.commer.Cc;
import com.yl.system.mapper.MinioMapper;
import com.yl.system.service.MinioService;
import com.yl.system.util.MinioConfig;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.net.URLConnection;
import java.nio.file.*;
import java.util.*;
import java.util.stream.Collectors;

import static com.google.common.io.Files.getFileExtension;

@Service
public class MinioServiceImpl implements MinioService {

    @Autowired
    private MinioMapper minioMapper;
    @Autowired
    private MinioConfig minioConfig;
    @Autowired
    private MybatisProperties mybatisProperties;


    @Override
    public void add(String multipartFile) throws IOException {
        File folder = new File(multipartFile);
        if (folder.exists() && folder.isDirectory()) {
            File[] files = folder.listFiles();
            List<String> folderNames = new ArrayList<>();
            if (files != null) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        folderNames.add(file.getName());
                    }
                }
            }
            // 打印获取到的文件夹名称，你可以根据需求修改这里的逻辑
            for (String name : folderNames) {
                System.out.println(name);
            }
        }

    }

    /**
     * 添加
     */

    @Override
    public String informationAdd(String filePath) {
        try {
            // 调用方法获取子文件夹和文件名称
            List<String> names = getSubFolderAndFiles(Paths.get(filePath));
            // 打印所有子文件夹和文件的名称
            names.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
            return "获取子目录失败";
        }
        return "添加成功";
    }


    // 获取指定路径下的所有子目录和文件
    public List<String> getSubFolderAndFiles(Path path) throws IOException {
        List<String> names = new ArrayList<>();

        // 先遍历目录，找到所有的 .xlsx 文件
        List<Path> xlsxFiles = Files.walk(path)
                .filter(p -> Files.isRegularFile(p) && p.toString().endsWith(".xlsx"))
                .collect(Collectors.toList());

        // 对于每个 .xlsx 文件，获取其同级目录以及其中的图片文件
        for (Path xlsx : xlsxFiles) {
            // 获取 .xlsx 文件的父目录
            Path parentDir = xlsx.getParent();

            // 打印父目录及其子目录和图片文件
            names.add("目录: " + parentDir.getFileName().toString());

            // 获取与 .xlsx 文件同级的所有目录
            List<String> siblingFolders = getSiblingFolders(parentDir);
            if (!siblingFolders.isEmpty()) {
                names.add("  同级目录:");
                siblingFolders.forEach(folder -> {
                    // 如果是 "头像及作品集" 目录，则进入查看
                    if (folder.equalsIgnoreCase("头像及作品集")) {
                        names.add("    " + folder + " 文件:");
                        // 打印该目录下的所有文件
                        try {
                            List<String> filesInFolder = getFilesInFolder(parentDir.resolve(folder));
                            filesInFolder.forEach(file -> names.add("      " + file));
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    } else {
                        names.add("    " + folder); // 普通同级目录，不需要额外处理
                    }
                });
            } else {
                names.add("  无同级目录");
            }

            // 获取该父目录下所有图片文件
            List<String> imageFiles = getImageFiles(parentDir);
            if (!imageFiles.isEmpty()) {
                names.add("  图片文件:");
                imageFiles.forEach(image -> names.add("    " + image));
            } else {
                names.add("  无图片文件");
            }

            // 记录当前 .xlsx 文件
            names.add("  xlsx 文件: " + xlsx.getFileName().toString());
            // 读取并打印 .xlsx 文件的内容
            try {
                List<String> excelContent = readExcelFile(xlsx);
                names.add("  xlsx 文件内容:");
                excelContent.forEach(content -> names.add("    " + content));
            } catch (IOException e) {
                names.add("    读取 xlsx 文件内容失败");
                e.printStackTrace();
            }

            names.add(""); // 分隔下一条记录
        }

        // 处理非 .xlsx 文件的目录
        List<Path> nonXlsxFiles = Files.walk(path)
                .filter(p -> Files.isRegularFile(p) && !p.toString().endsWith(".xlsx"))
                .collect(Collectors.toList());

        for (Path nonXlsx : nonXlsxFiles) {
            // 获取非 .xlsx 文件的父目录
            Path parentDir = nonXlsx.getParent();

            // 如果该目录中有图片文件，列出所有图片文件
            List<String> imageFiles = getImageFiles(parentDir);
            if (!imageFiles.isEmpty()) {
                names.add("目录 " + parentDir.getFileName().toString() + " 中的图片文件:");
                imageFiles.forEach(image -> names.add("    " + image));
            }
        }

        return names;
    }

    // 获取指定路径下所有子目录的名称
    private List<String> getSiblingFolders(Path parentDir) throws IOException {
        List<String> folderNames = new ArrayList<>();

        // 遍历父目录，获取所有子目录名称
        Files.list(parentDir)
                .filter(Files::isDirectory)  // 过滤出子目录
                .forEach(p -> folderNames.add(p.getFileName().toString()));

        return folderNames;
    }

    // 获取指定目录下的所有图片文件名称（如 .jpg, .png 等）
    private List<String> getImageFiles(Path parentDir) throws IOException {
        List<String> imageFiles = new ArrayList<>();

        // 遍历父目录，获取所有图片文件
        Files.list(parentDir)
                .filter(p -> Files.isRegularFile(p) && isImageFile(p))  // 过滤出图片文件
                .forEach(p -> imageFiles.add(p.getFileName().toString()));

        return imageFiles;
    }

    // 获取指定文件夹中的所有文件名称
    private List<String> getFilesInFolder(Path folderPath) throws IOException {
        List<String> filesInFolder = new ArrayList<>();

        // 遍历指定文件夹，获取所有文件名称
        Files.list(folderPath)
                .filter(Files::isRegularFile) // 只获取文件
                .forEach(file -> filesInFolder.add(file.getFileName().toString()));

        return filesInFolder;
    }

    // 判断文件是否是图片文件（可以扩展其他格式）
    private boolean isImageFile(Path path) {
        String fileName = path.toString().toLowerCase();
        return fileName.endsWith(".jpg") || fileName.endsWith(".jpeg") || fileName.endsWith(".png");
    }

    // 读取并打印 .xlsx 文件的内容
    private static String getCellValue(Cell cell) {
        if (cell == null) {
            return "空值"; // 返回"空值"如果单元格为空
        }
        switch (cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue();
            case NUMERIC:
                return String.valueOf(cell.getNumericCellValue());
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            default:
                return "空值";
        }
    }

    // 获取文件扩展名并推测 MIME 类型
//    private static String getFileTypeFromFileName(String fileName) {
//        String extension = fileName.substring(fileName.lastIndexOf('.') + 1).toLowerCase();
//        switch (extension) {
//            case "jpg":
//            case "jpeg":
//                return "jpeg";
//            case "png":
//                return "png";
//            case "gif":
//                return "gif";
//            case "bmp":
//                return "bmp";
//            case "pdf":
//                return "pdf";
//            default:
//                return "octet-stream"; // 默认二进制流
//        }
//    }

    // 读取 Excel 文件并提取头像路径和作品集路径
    public List<String> readExcelFile(Path xlsxFile) throws IOException {
        List<String> content = new ArrayList<>();

        try (FileInputStream fis = new FileInputStream(xlsxFile.toFile())) {
            Workbook workbook = new XSSFWorkbook(fis);  // 创建工作簿
            Sheet sheet = workbook.getSheetAt(0);      // 读取第一个工作表

            // 从第二行开始读取（跳过第0行）
            for (int rowIndex = 1; rowIndex < sheet.getPhysicalNumberOfRows(); rowIndex++) {
                Row row = sheet.getRow(rowIndex); // 获取当前行

                // 如果当前行为空，跳过
                if (row == null) {
                    System.out.println("跳过空行: " + rowIndex);
                    continue;
                }

                // 获取每一列的单元格
                Cell nameAndBioCell = row.getCell(0);
                Cell personalProfile = row.getCell(1);
                Cell avatarCell = row.getCell(2);
                Cell phoneUrlCell1 = row.getCell(3);
                Cell phoneUrlCell2 = row.getCell(4);
                Cell phoneUrlCell3 = row.getCell(5);

                // 跳过关键字段为空的行
                if (nameAndBioCell == null || personalProfile == null || avatarCell == null) {
                    System.out.println("跳过空数据行: " + rowIndex); // 输出跳过行的提示
                    continue;  // 跳过当前行，继续处理下一行
                }

                // 获取头像路径并上传
                String avatarPath = getCellValue(avatarCell);
                if (!"空值".equals(avatarPath)) {
                    uploadAvatar(avatarPath); // 上传头像
                }
//                // 获取头像路径并上传
//                String avatarPath = getCellValue(avatarCell);
//                if (!"空值".equals(avatarPath)) {
//                    uploadAvatar(avatarPath); // 上传头像
//                }
//                // 获取头像路径并上传
//                String avatarPath = getCellValue(avatarCell);
//                if (!"空值".equals(avatarPath)) {
//                    uploadAvatar(avatarPath); // 上传头像
//                }

                // 将当前行的内容收集到StringBuilder中
                StringBuilder rowContent = new StringBuilder();
                rowContent.append("姓名: ").append(getCellValue(nameAndBioCell)).append(", ");
                rowContent.append("个人简介: ").append(getCellValue(personalProfile)).append(", ");
                rowContent.append("头像路径: ").append(avatarPath).append(", ");
                rowContent.append("作品集1路径: ").append(getCellValue(phoneUrlCell1)).append(", ");
                rowContent.append("作品集2路径: ").append(getCellValue(phoneUrlCell2)).append(", ");
                rowContent.append("作品集3路径: ").append(getCellValue(phoneUrlCell3));

                // 将该行内容添加到列表中
                content.add(rowContent.toString());

                // 可选：如果仍然希望打印输出，可以在这里进行打印
                System.out.println("当前行: " + rowIndex + ", " + rowContent.toString());
            }
        }

        return content;
    }

    // 上传头像文件
    private void uploadAvatar(String avatarPath) throws IOException {
        File avatarFile = new File(avatarPath);
        if (avatarFile.exists()) {
            String contentType = "image/" + getFileTypeFromFileName(avatarPath);  // 根据文件名获取MIME类型
            try (FileInputStream fis = new FileInputStream(avatarFile)) {
                byte[] fileBytes = fis.readAllBytes();  // 获取文件字节内容
                MultipartFile multipartFile = new MockMultipartFile(
                        "file", // 文件字段名
                        avatarFile.getName(), // 文件名
                        contentType, // 文件MIME类型
                        fileBytes // 文件字节内容
                );
                // 上传到 MinIO
                String fileUrl = minioConfig.upload(multipartFile);  // 假设 minioConfig.upload() 返回文件的 URL
                System.out.println("上传成功: " + fileUrl);
            }
        } else {
            System.out.println("文件不存在: " + avatarPath);
        }
    }


    /**
     * 通过具体路径 递归列出文件夹中的所有图片文件
     *
     * @param fileName
     * @return
     */
//    public List<DanmoFontGenerate> listImageFilesInDirectory(String folderPath) throws IOException {
//        File folder = new File(folderPath);
//        List<DanmoFontGenerate> danmoFontGenerates = new ArrayList<>();
//
//        // 检查是否是目录
//        if (folder.isDirectory()) {
//            File[] files = folder.listFiles(); // 列出文件夹中的所有文件和子目录
//            System.out.println("Files in Folder: "+files);
//            if (files != null) { // 确保文件数组不为空
//                for (File file : files) {
//                    if (file.isFile() && isImageFile(file)) { // 检查是否是文件并且是图片
//                        System.out.println("Image File: " + file.getName()); // 打印图片文件名称
//                        String fileName  = file.getName();
//                        String[] parts = extractParts(fileName);
//                        if (parts != null) {
//                            System.out.println("字体: " + parts[0]);
//                            System.out.println("作者: " + parts[1]);
//                            System.out.println("字名: " + parts[2]);
//                        } else {
//                            System.out.println("文件名格式不正确.");
//                        }
//
//                        String folderName = extractFolderName(folderPath);
//                        if (folderName != null) {
//                            System.out.println("提取的文件夹名称: " + folderName); // 输出提取的文件夹名称
//                        } else {
//                            System.out.println("无法提取文件夹名称.");
//                        }
//                        DanmoFontGenerate danmoFontGenerate = new DanmoFontGenerate();
//                         danmoFontGenerate.setFont(parts[0]);
//                         danmoFontGenerate.setAuthor(parts[1]);
//                         danmoFontGenerate.setFontName(parts[2]);
//                         danmoFontGenerate.setWidth("130");
//                         danmoFontGenerate.setHigh("130");
//                         danmoFontGenerate.setTarnstram(0);
//
//
//                        if (folderName.equals("草书")){
//                            danmoFontGenerate.setFontTypeId(1);
//                        }if (folderName.equals("行书")){
//                            danmoFontGenerate.setFontTypeId(2);
//                        }if (folderName.equals("隶书")){
//                            danmoFontGenerate.setFontTypeId(3);
//                        }if (folderName.equals("宋体")){
//                            danmoFontGenerate.setFontTypeId(4);
//                        }if (folderName.equals("楷书")){
//                            danmoFontGenerate.setFontTypeId(5);
//                        }if (folderName.equals("黑体")){
//                            danmoFontGenerate.setFontTypeId(7);
//                        }if (folderName.equals("甲骨文")){
//                            danmoFontGenerate.setFontTypeId(8);
//                        }if (folderName.equals("石鼓文")){
//                            danmoFontGenerate.setFontTypeId(9);
//                        }if (folderName.equals("今草")){
//                            danmoFontGenerate.setFontTypeId(10);
//                        }if (folderName.equals("正书")){
//                            danmoFontGenerate.setFontTypeId(11);
//                        }if (folderName.equals("狂草")){
//                            danmoFontGenerate.setFontTypeId(12);
//                        }if (folderName.equals("龟书")){
//                            danmoFontGenerate.setFontTypeId(13);
//                        }if (folderName.equals("鸟书")){
//                            danmoFontGenerate.setFontTypeId(14);
//                        }if (folderName.equals("云书")){
//                            danmoFontGenerate.setFontTypeId(15);
//                        }if (folderName.equals("鱼书")){
//                            danmoFontGenerate.setFontTypeId(16);
//                        }if (folderName.equals("叶根友行书简体")){
//                            danmoFontGenerate.setFontTypeId(17);
//                        }if (folderName.equals("细体")){
//                            danmoFontGenerate.setFontTypeId(18);
//                        }if (folderName.equals("综艺体")){
//                            danmoFontGenerate.setFontTypeId(19);
//                        }if (folderName.equals("倒薤书")){
//                            danmoFontGenerate.setFontTypeId(20);
//                        }if (folderName.equals("钟鼎书（金文）")) {
//                            danmoFontGenerate.setFontTypeId(21);
//                        }
//                        File imageFile = new File(folderPath + "/" + fileName);
//                        FileInputStream inputStream = new FileInputStream(imageFile);
//                        byte[] fileBytes = inputStream.readAllBytes(); // 注意：对于大文件，建议使用循环读取
//                        inputStream.close();
//
//                        // 创建 MockMultipartFile 实例
//                        String contentType = "image/" + getFileTypeFromFileName(fileName); // 根据文件名获取MIME类型，这里需要简单实现一下
//                        MultipartFile multipartFile = new MockMultipartFile(
//                                "file", // 文件字段名
//                                fileName, // 文件名
//                                contentType, // 文件MIME类型
//                                fileBytes // 文件字节内容
//                        );
//                        danmoFontGenerate.setFontPicture(this.minioConfig.upload(multipartFile));
//                        danmoFontGenerates.add(danmoFontGenerate);
//                    }
//                }
//            } else {
//                System.out.println("该目录为空或无法读取文件.");
//            }
//        } else {
//            System.out.println("提供的路径不是一个有效的目录.");
//        }
//        return danmoFontGenerates;
//    }
    // 简单实现根据文件名获取MIME类型的方法
    private static String getFileTypeFromFileName(String fileName) {
        if (fileName.endsWith(".jpg") || fileName.endsWith(".jpeg")) {
            return "jpeg";
        } else if (fileName.endsWith(".png")) {
            return "png";
        } else if (fileName.endsWith(".gif")) {
            return "gif";
        } else {
            // 默认返回 "octet-stream" 表示未知类型
            return "octet-stream";
        }
    }


    // 判断文件是否是图片
    public static boolean isImageFile(File file) {
        String fileName = file.getName().toLowerCase();
        return fileName.endsWith(".jpg") || fileName.endsWith(".jpeg") ||
                fileName.endsWith(".png") || fileName.endsWith(".gif") ||
                fileName.endsWith(".bmp") || fileName.endsWith(".tiff");
    }

    //获取名称
    public static String[] extractParts(String fileName) {
        // 去掉文件扩展名
        String baseName = fileName.substring(0, fileName.lastIndexOf('-'));

        // 使用 "-" 分割字符串
        String[] parts = baseName.split("-");

        // 检查是否有足够的部分
        if (parts.length >= 3) {
            return new String[]{parts[0], parts[1], parts[2]}; // 返回提取的部分
        }

        return null; // 如果格式不正确，返回 null
    }

    //提取类型
    public static String extractFolderName(String path) {
        // 按 "\\" 分割路径
        String[] parts = path.split("\\\\");

        // 检查数组长度并返回倒数第二个部分
        if (parts.length >= 2) {
            return parts[parts.length - 2]; // 返回倒数第二个部分，即“草书”
        }

        return null; // 如果路径格式不正确，返回 null
    }


    private List<DanmoFontGenerate> listImageFilesInDirectoryRecursively(File folder) throws IOException, InterruptedException {
        List<DanmoFontGenerate> danmoFontGenerates = new ArrayList<>();

        if (folder.isDirectory()) {
            File[] files = folder.listFiles();

            if (files != null) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        // 递归处理子目录
                        danmoFontGenerates.addAll(listImageFilesInDirectoryRecursively(file));
                    } else if (isImageFile(file)) {
                        // 处理图片文件
//                        System.out.println("正在处理文件: " + file.getName());
//                        System.out.println(" folder.getParentFile().getName(): " + folder.getParentFile().getName());
                        DanmoFontGenerate danmoFontGenerate = processImageFile(file, folder.getParentFile().getName());
//                        System.out.println(" danmoFontGenerate: " + danmoFontGenerate);
                        if (danmoFontGenerate != null) {
                            danmoFontGenerates.add(danmoFontGenerate);
                        }
                    }
                }
            } else {
                System.out.println("该目录为空或无法读取文件.");
            }
        } else {
            System.out.println("提供的路径不是一个有效的目录.");
        }

        return danmoFontGenerates;
    }

    private DanmoFontGenerate processImageFile(File file, String folderName) throws IOException, InterruptedException {
        String fileName = file.getName();
        String[] parts = extractParts(fileName);
        if (parts == null) {
            System.out.println("文件名格式不正确: " + fileName);
            return null;
        }

        DanmoFontGenerate danmoFontGenerate = new DanmoFontGenerate();
        danmoFontGenerate.setFont(parts[0]);
        danmoFontGenerate.setAuthor(parts[1]);
        danmoFontGenerate.setFontName(parts[2]);
        danmoFontGenerate.setWidth("80");
        danmoFontGenerate.setHigh("80");
        danmoFontGenerate.setTarnstram(0L);

        if (folderName.equals("草书")) {
            danmoFontGenerate.setFontTypeId(1L);
        }
        if (folderName.equals("行书")) {
            danmoFontGenerate.setFontTypeId(2L);
        }
        if (folderName.equals("隶书")) {
            danmoFontGenerate.setFontTypeId(3L);
        }
        if (folderName.equals("宋体")) {
            danmoFontGenerate.setFontTypeId(4L);
        }
        if (folderName.equals("楷书")) {
            danmoFontGenerate.setFontTypeId(5L);
        }
        if (folderName.equals("小楷")) {
            danmoFontGenerate.setFontTypeId(6L);
        }
        if (folderName.equals("黑体")) {
            danmoFontGenerate.setFontTypeId(7L);
        }
        if (folderName.equals("甲骨文")) {
            danmoFontGenerate.setFontTypeId(8L);
        }
        if (folderName.equals("石鼓文")) {
            danmoFontGenerate.setFontTypeId(9L);
        }
        if (folderName.equals("今草")) {
            danmoFontGenerate.setFontTypeId(10L);
        }
        if (folderName.equals("正书")) {
            danmoFontGenerate.setFontTypeId(11L);
        }
        if (folderName.equals("狂草")) {
            danmoFontGenerate.setFontTypeId(12L);
        }
        if (folderName.equals("龟书")) {
            danmoFontGenerate.setFontTypeId(13L);
        }
        if (folderName.equals("鸟书")) {
            danmoFontGenerate.setFontTypeId(14L);
        }
        if (folderName.equals("云书")) {
            danmoFontGenerate.setFontTypeId(15L);
        }
        if (folderName.equals("鱼书")) {
            danmoFontGenerate.setFontTypeId(16L);
        }
        if (folderName.equals("叶根友行书简体")) {
            danmoFontGenerate.setFontTypeId(17L);
        }
        if (folderName.equals("细体")) {
            danmoFontGenerate.setFontTypeId(18L);
        }
        if (folderName.equals("综艺体")) {
            danmoFontGenerate.setFontTypeId(19L);
        }
        if (folderName.equals("倒薤书")) {
            danmoFontGenerate.setFontTypeId(20L);
        }
        if (folderName.equals("钟鼎书（金文）")) {
            danmoFontGenerate.setFontTypeId(21L);
        }

        if (folderName.equals("魏碑")) {
            danmoFontGenerate.setFontTypeId(22L);
        }
        if (folderName.equals("行草")) {
            danmoFontGenerate.setFontTypeId(23L);
        }
        if (folderName.equals("章草")) {
            danmoFontGenerate.setFontTypeId(24L);
        }
        if (folderName.equals("篆书")) {
            danmoFontGenerate.setFontTypeId(25L);
        }


//        try (FileInputStream inputStream = new FileInputStream(file)) {
//            byte[] fileBytes = inputStream.readAllBytes();
//            String contentType = URLConnection.guessContentTypeFromStream(new ByteArrayInputStream(fileBytes));
//            if (contentType == null) {
//                // 如果无法推测出类型，使用之前的方法
//                contentType = "image/" + getFileExtension(file.getName());
//            }
//
//            // 将图片字节数组转换为 Base64 编码
//            String base64Image = Base64.getEncoder().encodeToString(fileBytes);
//            // 添加数据 URI 前缀
//            String dataUriPrefix = "data:" + contentType + ";base64,";
//            String base64ImageWithPrefix = dataUriPrefix + base64Image;
//            danmoFontGenerate.setFontPicture(base64ImageWithPrefix);
//
//        }

//       FileInputStream inputStream = new FileInputStream(file);
//            byte[] fileBytes = inputStream.readAllBytes();
//            String contentType = "image/" + getFileTypeFromFileName(fileName);
//            MultipartFile multipartFile = new MockMultipartFile(
//                    "file",
//                    fileName,
//                    contentType,
//                    fileBytes
//            );
         File file1 = Cc.convertPngToSvg(file);
        MultipartFile multipartFile = Cc.convertFileToMultipartFile(file1);
        String upload = this.minioConfig.upload(multipartFile);

        danmoFontGenerate.setSvgUrl(upload); // 假设 minioConfig 有一个 upload 方法用于上传文件
        danmoFontGenerate.setId(IdWorker.getId());

        String s = tableName(danmoFontGenerate.getFontTypeId());
        minioMapper.minioAddTable(danmoFontGenerate, s);
        return danmoFontGenerate;
    }

    private String tableName(Long fontTypeId) {

        if (fontTypeId == 1) {
            return "danmo_font_caoshu";
        }
        if (fontTypeId == 2) {
            return "danmo_font_hangshu";
        }
        if (fontTypeId == 3) {
            return "danmo_font_lishu";
        }
        if (fontTypeId == 5) {
            return "danmo_font_kaishu";
        }
        if (fontTypeId == 6) {
            return "danmo_font_xiaokai";
        }
        if (fontTypeId == 22) {
            return "danmo_font_weibei";
        }
        if (fontTypeId == 23) {
            return "danmo_font_hangcao";
        }
        if (fontTypeId == 24) {
            return "danmo_font_zhangcao";
        }
        if (fontTypeId == 25) {
            return "danmo_font_zhuanshu";
        }
        return null;

    }


    @Override
    public void addWord(String filePath) throws IOException, InterruptedException {
        File f = new File(filePath);
        List<DanmoFontGenerate> danmoFontGenerates = listImageFilesInDirectoryRecursively(f);
//        System.out.println("danmoFontGenerates:"+danmoFontGenerates);
    }

    @Override
    public String base64ToSvg() throws IOException, InterruptedException {

        int offset = 0;
        int limit = 200;

        while (true) {
            List<DanmoFontGenerate> danmoFontGenerates = minioMapper.selectFont(offset, limit);
            if (danmoFontGenerates.isEmpty()) {
                break;
            }

            for (DanmoFontGenerate danmoFontGenerate : danmoFontGenerates) {
                File file1 = Cc.convertBase64ToPngFile(danmoFontGenerate.getFontPicture());
                File file = Cc.convertPngToSvg(file1);
                MultipartFile multipartFile = Cc.convertFileToMultipartFile(file);
                String upload = this.minioConfig.upload(multipartFile);

                DanmoFontGenerate updatedGenerate = new DanmoFontGenerate();
                updatedGenerate.setId(IdWorker.getId());
                updatedGenerate.setSvgUrl(upload);
                minioMapper.update(updatedGenerate);
                file1.delete();
            }
            System.out.println(offset+"页");
            System.out.println(limit+"条已完成");
            offset += limit;
        }
        return "成功";
    }

    @Override
    public String getSubFolderAndFiles(String a) throws IOException, InterruptedException {
//        File file1 = Cc.convertBase64ToPngFile(a);
        File file1 = new File(a);
        File file = Cc.convertPngToSvg(file1);
        MultipartFile multipartFile = Cc.convertFileToMultipartFile(file);
        String upload = this.minioConfig.upload(multipartFile);
        System.out.println(upload);
        return upload;
    }
//    int offset = 0;
//    int limit = 200;
//    List<DanmoFontGenerate> toUpdateList = new ArrayList<>();
//
//        while (true) {
//        List<DanmoFontGenerate> danmoFontGenerates = minioMapper.selectFont(offset, limit);
//        if (danmoFontGenerates.isEmpty()) {
//            break;
//        }
//
//        for (DanmoFontGenerate danmoFontGenerate : danmoFontGenerates) {
//            File file = Cc.convertPngToSvg(new File(danmoFontGenerate.getFontPicture()));
//            MultipartFile multipartFile = Cc.convertFileToMultipartFile(file);
//            String uploadUrl = minioConfig.upload(multipartFile);
//
//            DanmoFontGenerate updatedGenerate = new DanmoFontGenerate();
//            updatedGenerate.setId(danmoFontGenerate.getId());
//            updatedGenerate.setSvgUrl(uploadUrl);
//            toUpdateList.add(updatedGenerate);
//        }
//
//        // 批量更新
//        minioMapper.batchUpdate(toUpdateList);
//        toUpdateList.clear();
//
//        offset += limit;
//    }

//    List<DanmoFontGenerate>  danmoFontGenerates= minioMapper.selcetFont();
//        System.out.println("查询成功");
//        for (DanmoFontGenerate danmoFontGenerate : danmoFontGenerates) {
//        File file1 = Cc.convertBase64ToPngFile(danmoFontGenerate.getFontPicture());
//        File file = Cc.convertPngToSvg(file1);
//        MultipartFile multipartFile = Cc.convertFileToMultipartFile(file);
//        String upload = this.minioConfig.upload(multipartFile);
//        DanmoFontGenerate danmoFontGenerate1 = new DanmoFontGenerate();
//        danmoFontGenerate1.setSvgUrl(upload);
//        danmoFontGenerate1.setId(danmoFontGenerate.getId());
//        minioMapper.update(danmoFontGenerate1);
//        System.out.println("第"+danmoFontGenerate.getId()+"条数据");
//    }


}
